home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / Gfx / Edit / TSMorph / src / apack.asm next >
Assembly Source File  |  1994-10-30  |  8KB  |  254 lines
  1.  
  2. **************************************************************** 
  3. * 
  4. *  Copyright 1988 by CREATIVE FOCUS.  This code is freely 
  5. *  distributable as long as this notice is retained and no 
  6. *  other conditions are imposed upon its redistribution. 
  7. * 
  8. * 
  9. *  APACK.ASM --  
  10. * 
  11. *  A fully compatible replacement for Electronic Arts' PACKER.C 
  12. *  routine.  Converts data according to the IFF ILBM cmpByteRun1 
  13. *  compression protocol: 
  14. * 
  15. *     control bytes: 
  16. * 
  17. *        n =  0.. 127:   followed by n+1 bytes of data; 
  18. *        n = -1..-127:   followed by byte to be repeated -n+1 times; 
  19. *        n =     -128:   don't do no nada. 
  20. * 
  21. *     calling format: 
  22. * 
  23. *        long packrow(from, too, amt) 
  24. *           char **from, /* pointer to source data pointer */ 
  25. *                **too;  /* pointer to destination data pointer */ 
  26. *           long amt;    /* number of bytes to compress */ 
  27. * 
  28. *        return(number of bytes written to destination); 
  29. * 
  30. *     effects: 
  31. * 
  32. *         *from = *from + amt, and *too = *too + return; 
  33. *         return is "smart," that is, not greater than 
  34. *         MaxPackedSize = amt + ((amt+127) >> 7). 
  35. * 
  36. *     By commenting out CHECK (below) you disable checking for runs 
  37. *     exceeding 128 bytes.  That CHECK is not needed if you are sure 
  38. *     the amt to be compressed is always 128 or less. 
  39. * 
  40. *  !!! DISCLAIMER !!!  You use this code entirely at your own 
  41. *  risk.  I don't warrantee its fitness for any purpose.  I 
  42. *  can't even guarantee the accuracy of anything I've said 
  43. *  about it, though I've tried my damndest to get it right. 
  44. *  I may, in fact, be completely out of my tiny little mind :-). 
  45. * 
  46. *  That being said, I can be reached for questions, comments, 
  47. *  or concerns at: 
  48. * 
  49. *        Dr. Gerald Hull 
  50. *        CREATIVE FOCUS 
  51. *        12 White Street 
  52. *        Binghamton, N.Y.  13901 
  53. *        (607) 648-4082 
  54. * 
  55. *        bix:    ghull 
  56. *        PLink:  DRJERRY 
  57. * 
  58. *************************************************************** 
  59.  
  60. * edited by mjp to compile with SAS/C 5.10
  61.  
  62.    xdef  _packrow 
  63.  
  64.     section code
  65.  
  66. *a0    equr  a0                -> beginning of replicate run (if any) 
  67. *a1    equr  a1                -> end+1 of input line 
  68. *a2    equr  a2                -> beginning of literal run (if any) 
  69. *a3    equr  a3                -> end+1 of lit and/or rep run (if any) 
  70. *a4    equr  a4                -> end+1 of output line current pos 
  71. *a5    equr  a6                frame pointer 
  72. *a7    equr  a7                stack pointer 
  73.  
  74. *d0    equr  d0                return value 
  75. *d1    equr  d1                check for maximum run = MAX 
  76. *d2    equr  d2                amount 
  77. *d3    equr  d3                character 
  78.  
  79. *d2/d3/a2/a3/a4  reg   d2/d3/a2/a3/a4 
  80.  
  81. FRM   equ   8                 input line address 
  82. TOO   equ   12                output line address 
  83. AMT   equ   16                length of input line 
  84.  
  85. MAX   equ   128               maximum encodable output run 
  86. CHECK equ   1                 turns on maximum row checking 
  87.  
  88.  
  89. _packrow 
  90.  
  91.  
  92. ***************     CASE 0:   GRAB PARAMS & INITIALIZE 
  93. CAS0 
  94.       link     a5,#0 
  95.       movem.l  d2/d3/a2/a3/a4,-(a7) 
  96.       movea.l  FRM(a5),a2 
  97.       movea.l  (a2),a2        a2 = *from 
  98.       movea.l  a2,a3          a3 = a2 
  99.       movea.l  a3,a1 
  100.       adda.l   AMT(a5),a1     a1 = a2 + amt 
  101.       movea.l  TOO(a5),a4 
  102.       movea.l  (a4),a4        a4 = *too 
  103.  
  104.  
  105. ***************     CASE 1:   LITERAL RUN 
  106. CAS1 
  107.       movea.l  a3,a0          adjust a0 (no replicates yet!) 
  108.       move.b   (a3)+,d3       grab character 
  109.       cmpa.l   a3,a1          if input is finished 
  110.       beq.s    CAS5              branch to case 5 
  111.  
  112.       ifd      CHECK 
  113.       move.l   a3,d1 
  114.       sub.l    a2,d1 
  115.       cmpi     #MAX,d1        if run has reached MAX 
  116.       beq.s    CAS6              branch to case 6 
  117.       endc 
  118.  
  119.       cmp.b    (a3),d3        if next character != d3 
  120.       bne.s    CAS1              stay in case 1 
  121.  
  122. *                             else fall into case 2 
  123.  
  124.  
  125. ***************     CASE 2:   AT LEAST 2 BYTE REPEAT 
  126. CAS2 
  127.       move.b   (a3)+,d3       grab character 
  128.       cmpa.l   a3,a1          if input is finished 
  129.       beq.s    CAS7              branch to case 7 
  130.  
  131.       ifd      CHECK 
  132.       move.l   a3,d1 
  133.       sub.l    a2,d1 
  134.       cmpi     #MAX,d1        if run has reached MAX 
  135.       beq.s    CAS6              branch to case 6 
  136.       endc 
  137.  
  138.       cmp.b    (a3),d3        if next character != d3 
  139.       bne.s    CAS1              branch to case 1 
  140.  
  141. *                             else fall into case 3 
  142.  
  143.  
  144. ***************     CASE 3:   REPLICATE RUN 
  145. CAS3 
  146.       move.b   (a3)+,d3       grab character 
  147.       cmpa.l   a3,a1          if input is finished 
  148.       beq.s    CAS7              branch to case 7 
  149.  
  150.       ifd      CHECK 
  151.       move.l   a3,d1 
  152.       sub.l    a0,d1 
  153.       cmpi     #MAX,d1        if run has reached MAX 
  154.       beq.s    CAS4              branch to case 4 
  155.       endc 
  156.  
  157.       cmp.b    (a3),d3        if next character = d3 
  158.       beq.s    CAS3              stay in case 3 
  159.  
  160. *                             else fall into case 4 
  161.  
  162.  
  163. ***************     CASE 4:   LIT AND/OR REP DUMP & CONTINUE 
  164. CAS4 
  165.       move.l   a0,d2 
  166.       sub.l    a2,d2          d2 = a0 - a2 
  167. *                             if no literal run 
  168.       beq.s    C41               branch to replicate run 
  169.  
  170.       subq     #1,d2          d2 = d2 - 1 
  171.       move.b   d2,(a4)+       output literal control byte 
  172.  
  173. C40   move.b   (a2)+,(a4)+    output literal run 
  174.       dbra     d2,C40 
  175.  
  176. C41   move.l   a0,d2 
  177.       sub.l    a3,d2          d2 = a0 - a3 (negative result!) 
  178.       addq     #1,d2          d2 = d2 + 1 
  179.       move.b   d2,(a4)+       output replicate control byte 
  180.       move.b   d3,(a4)+       output repeated character 
  181.       movea.l  a3,a2          reset a2 
  182.       bra.s    CAS1           branch to case 1 (not done) 
  183.  
  184.  
  185. ***************     CASE 5:   LITERAL DUMP & QUIT 
  186. CAS5 
  187.       move.l   a3,d2 
  188.       sub.l    a2,d2          d2 = a3 - a2 (positive result > 0) 
  189.       subq     #1,d2          d2 = d2 - 1 
  190.       move.b   d2,(a4)+       output literal control byte 
  191.  
  192. C50   move.b   (a2)+,(a4)+    output literal run 
  193.       dbra     d2,C50 
  194.  
  195.       bra.s    CAS8           branch to case 8 (done) 
  196.  
  197.  
  198.       ifd      CHECK 
  199.  
  200. ***************     CASE 6:   LITERAL DUMP & CONTINUE 
  201. CAS6 
  202.       move.l   a3,d2 
  203.       sub.l    a2,d2          d2 = a3 - a2 (positive result > 0) 
  204.       subq     #1,d2          d2 = d2 - 1 
  205.       move.b   d2,(a4)+       output literal control byte 
  206.  
  207. C60   move.b   (a2)+,(a4)+    output literal run 
  208.       dbra     d2,C60 
  209.  
  210.       bra      CAS1           branch to case 1 (not done) 
  211.  
  212.       endc 
  213.  
  214.  
  215. ***************     CASE 7:   LIT AND/OR REP DUMP & FINISH 
  216. CAS7 
  217.       move.l   a0,d2 
  218.       sub.l    a2,d2          d2 = a0 - a2 (positive result > 0) 
  219. *                             if no literal run 
  220.       beq.s    C71               branch to replicate run 
  221.  
  222.       subq     #1,d2          d2 = d2 - 1 
  223.       move.b   d2,(a4)+       output literal control byte 
  224.  
  225. C70   move.b   (a2)+,(a4)+    output literal run 
  226.       dbra     d2,C70 
  227.  
  228. C71   move.l   a0,d2 
  229.       sub.l    a3,d2          d2 = a0 - a3 (negative result) 
  230.       addq     #1,d2          d2 = d2 + 1 
  231.       move.b   d2,(a4)+       output replicate control byte 
  232.       move.b   d3,(a4)+       output repeated character 
  233.  
  234. *                             fall into case 8 
  235.  
  236.  
  237. ***************     CASE 8:   ADJUST PARAMS & RETURN VALUE 
  238. CAS8 
  239.       movea.l  FRM(a5),a0     a0 = **from 
  240.       move.l   a3,(a0)        *from = *from + amt 
  241.       movea.l  TOO(a5),a0     a0 = **too 
  242.  
  243.       move.l   a4,d0 
  244.       sub.l    (a0),d0       return = a4 - *too  
  245.  
  246.       move.l   a4,(a0)       *too = *too + return 
  247.       movem.l  (a7)+,d2/d3/a2/a3/a4 
  248.       UNLK     a5 
  249.       rts 
  250.  
  251.       end
  252.  
  253.  
  254.